home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / PROGENV / ClassTree.C < prev    next >
C/C++ Source or Header  |  1992-07-02  |  14KB  |  616 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "ClassTree.h"
  6.  
  7. #include "ET++.h"
  8. #include "Zoomer.h"
  9. #include "OrdColl.h"
  10. #include "Set.h"
  11. #include "AccessMem.h"
  12. #include "ClassManager.h"
  13. #include "String.h"
  14.  
  15. #include "ClassItem.h"
  16. #include "ProgEnv.h"
  17. #include "EtPeCmdNo.h"
  18. #include "EtPeManager.h"
  19.  
  20. static RGBColor *c1;
  21. static OrdCollection *treeViews= 0;
  22.  
  23. ONEXIT(PeClassTree)
  24. {
  25.     SafeDelete(c1);
  26. }
  27.  
  28. //---- PeClassTreeView ----------------------------------------------------------
  29.  
  30. NewMetaImpl0(PeClassTreeView, TreeView);
  31.  
  32. PeClassTreeView::PeClassTreeView(EvtHandler *eh, Class *root) 
  33.                      : TreeView(eh, eTLLeftRight, eTCDiagonal2)
  34. {
  35.     if (treeViews == 0)
  36.     treeViews= new OrdCollection;
  37.     treeViews->Add(this);
  38.     
  39.     gClassManager->SetupSubclasses();
  40.     classes= new OrdCollection(200);
  41.     InstallTree(root);  
  42.     show= ePeCTShowAll; 
  43.     references= new OrdCollection;
  44. }
  45.  
  46. PeClassTreeView::~PeClassTreeView()
  47. {
  48.     SafeDelete(classes);
  49.     treeViews->RemovePtr(this);
  50.     if (treeViews->Size() == 0)
  51.     SafeDelete(treeViews);
  52.     if (references) {
  53.     references->FreeAll();
  54.     SafeDelete(references);
  55.     }
  56. }
  57.  
  58. VObject *PeClassTreeView::NodeAsVObject(Object *op)
  59. {
  60.     Class *cl= Guard(op, Class);
  61.     VObject *vop= new PeClassItem(cIdClassItem, cl);
  62.     classes->Add(vop);
  63.     return vop;    
  64. }
  65.  
  66. Iterator *PeClassTreeView::MakeChildrenIter(Object *op)
  67. {
  68.     return Guard(op, Class)->SubclassIterator();
  69. }
  70.  
  71. Command *PeClassTreeView::GetNodeSelector(TreeNode *tn, int cl)
  72. {
  73.     VObject *vop= tn->At(0)->FindItem(cIdClassItem);
  74.     if (vop && vop->IsKindOf(PeClassItem) && vop->TestFlag(eClItemCollapsed)) 
  75.     return new PeNameTreeNodeSelector(tn, cl);
  76.     return TreeView::GetNodeSelector(tn, cl);
  77. }
  78.  
  79. void PeClassTreeView::ShowClass(Class *cl)
  80. {
  81.     PeClassItem *ci= FindClassItem(cl);
  82.     if (ci) {
  83.     RevealRect(ci->ContentRect().Expand(100), Point(0, 100));
  84.     SetSelection((VObject*)ci->GetNextHandler());
  85.     UpdateEvent();
  86.     }
  87. }
  88.  
  89. void PeClassTreeView::SetSelection(VObject *vop)
  90. {
  91.     TreeView::SetSelection(vop);
  92.     SynchSelection();
  93. }
  94.  
  95. void PeClassTreeView::SynchSelection()
  96. {
  97.     VObject *sel= GetSelection();
  98.     PeClassItem *cl= 0, *cl2= 0;
  99.     
  100.     if (sel)
  101.     cl= Guard(sel->FindItem(cIdClassItem), PeClassItem);
  102.     if (treeViews && cl) {
  103.     Iter next(treeViews);
  104.     PeClassTreeView *tvp;
  105.     while (tvp= (PeClassTreeView*)next()) {
  106.         VObject *sel2= tvp->GetSelection();
  107.         if (sel2)
  108.         cl2= Guard(sel2->FindItem(cIdClassItem), PeClassItem);
  109.         if (cl2->GetClass() != cl->GetClass())
  110.         tvp->ShowClass(cl->GetClass());
  111.     }
  112.     }
  113. }
  114.  
  115. Class *PeClassTreeView::GetRootClass()
  116. {
  117.     TreeNode *tn= GetTree();
  118.     PeClassItem *cl= Guard(GetTree()->FindItem(cIdClassItem), PeClassItem);
  119.     return cl->GetClass();
  120. }
  121.  
  122. void PeClassTreeView::ShowAllClasses()
  123. {
  124.     show= ePeCTShowAll; 
  125.     classes->ForEach(PeClassItem,ResetFlag)(eClItemCollapsed);
  126.     CalcLayout();
  127. } 
  128.  
  129. void PeClassTreeView::ShowOnlyAbstractClasses()
  130. {
  131.     Iter next(classes);
  132.     PeClassItem *cl;
  133.     show= ePeCTShowAbstract; 
  134.     classes->ForEach(PeClassItem,ResetFlag)(eClItemCollapsed);
  135.     while (cl= (PeClassItem*)next()) 
  136.     if (!cl->GetClass()->IsAbstract())
  137.         cl->SetFlag(eClItemCollapsed);
  138.     CalcLayout();
  139. }
  140.  
  141. void PeClassTreeView::ShowOnlyApplicationClasses()
  142. {
  143.     static char *etsrc= 0;
  144.     Iter next(classes);
  145.     PeClassItem *cl;
  146.     char buf[1024];
  147.     if (etsrc == 0)
  148.     etsrc= strprintf("%s/src", gEtDir);
  149.     int len= strlen(etsrc);
  150.     
  151.     show= ePeCTShowApp; 
  152.     classes->ForEach(PeClassItem,ResetFlag)(eClItemCollapsed);
  153.     while (cl= (PeClassItem*)next()) {
  154.     Class *cp= cl->GetClass();
  155.     if (gEtPeManager->FileOfClass(cp, buf, TRUE)) {
  156.         if (strncmp(etsrc, buf, len) == 0)
  157.         cl->SetFlag(eClItemCollapsed);
  158.     }
  159.     }
  160.     CalcLayout();
  161. }
  162.  
  163. PeCTreeShow PeClassTreeView::Shows()
  164. {
  165.     return show;
  166. }
  167.  
  168. void PeClassTreeView::DoSetupMenu(Menu *menu)
  169. {
  170.     TreeView::DoSetupMenu(menu);
  171.     VObject *sel= GetSelection();
  172.     if (sel) {
  173.     TreeNode *tn= FindTreeNode(sel);
  174.     char *current;
  175.     if (tn->Collapsed())
  176.         current= "Expand";
  177.     else
  178.         current= "Collapse";        
  179.     menu->ReplaceItem(cDOCOLLAPSE, current);
  180.     }    
  181. }
  182.  
  183. Command *PeClassTreeView::DoMenuCommand(int cmd)
  184. {
  185.     VObject *sel= GetSelection();
  186.     PeClassItem *cl= 0;
  187.     
  188.     if (sel)
  189.     cl= Guard(selection->FindItem(cIdClassItem), PeClassItem);
  190.     
  191.     switch (cmd) {
  192.     case cMEMBERS:
  193.     ShowMembers(cl);
  194.     break;
  195.     
  196.     case cCLIENTS:
  197.     ShowAllClients(cl);
  198.     break;
  199.     
  200.     case cSOURCE:
  201.     Control(cPeHierBrowser, cPeShowBrowser, cl->GetClass());
  202.     break;
  203.     
  204.     case cSPAWN:
  205.     Control(cPeHierBrowser, cPeSpawnHier, gClassManager->Find("Object"));
  206.     break;
  207.     
  208.     case cDOCOLLAPSE:
  209.     Collapse(FindTreeNode(selection));
  210.     break;
  211.     
  212.     case cPROMOTE:
  213.     Control(cPeHierBrowser, cPeSpawnHier, cl->GetClass());
  214.     break;
  215.     
  216.     case cTREEVIEW:
  217.     SetLayout(eTLLeftRight);
  218.     break;
  219.  
  220.     case cOUTLINEVIEW:
  221.     SetLayout(eTLIndented);
  222.     break;
  223.  
  224.     default:
  225.     return TreeView::DoMenuCommand(cmd);
  226.     }
  227.     return gNoChanges;
  228. }
  229.  
  230. void PeClassTreeView::Draw(Rectangle r)
  231. {
  232.     if (references) {
  233.     references->ForEach(PeClassReference,Draw)(r);
  234.     }
  235.     TreeView::Draw(r);
  236. }
  237.  
  238. void PeClassTreeView::AddReference(PeClassReference *cr)
  239. {
  240.     references->Add(cr); 
  241.     InvalidateRect(cr->BBox());       
  242. }
  243.  
  244. void PeClassTreeView::RemoveAllReferences()
  245. {
  246.     references->FreeAll();
  247.     references->Empty(0);
  248.     ForceRedraw();
  249. }
  250.  
  251. void PeClassTreeView::OpenTreeNode(TreeNode *tn, bool)
  252. {
  253.     if (references->Size() == 0)
  254.     return;
  255.     Iter next(references);
  256.     VObject *ci= tn->At(0)->FindItem(cIdClassItem);
  257.     if (ci && ci->IsKindOf(PeClassItem)) {
  258.     PeClassReference *cr;
  259.     while (cr= (PeClassReference*)next()) {
  260.         if (cr->Includes((PeClassItem*)ci)) 
  261.         InvalidateRect(cr->BBox()); 
  262.     }      
  263.     }
  264. }
  265.  
  266. //---- PeCollectClassMembers -----------------------------------------------------
  267.  
  268. class PeCollectClassMembers : public AccessMembers {
  269.     Collection *cp;
  270. public:
  271.     PeCollectClassMembers()
  272.     { cp= new OrdCollection; }
  273.     ~PeCollectClassMembers()
  274.     { SafeDelete(cp); }
  275.     void Member(char *, int, int, int, Class *cl, bool, bool)
  276.     { cp->Add(cl); }
  277.     Collection *GetCollection()
  278.     { return cp; }
  279. };
  280.  
  281. void PeClassTreeView::ShowMembers(PeClassItem *ci)
  282. {
  283.     PeCollectClassMembers clm;
  284.     Class *cp= ci->GetClass(), *clp;
  285.     Collection *colItems= new OrdCollection;
  286.     
  287.     cp->EnumerateMyMembers(&clm);
  288.     Iter next(clm.GetCollection());
  289.     while (clp= (Class *)next()) 
  290.     colItems->Add(FindClassItem(clp));
  291.     AddReference (new PeMemberReference(ci, colItems));        
  292. }
  293.  
  294. //---- PeCollectClients ----------------------------------------------------------
  295.  
  296. class PeCollectClients : public AccessMembers {
  297.     Collection *colp;
  298.     Class *clp, *current;
  299. public:
  300.     PeCollectClients(Class *c)
  301.     { colp= new Set; clp= c; }
  302.     ~PeCollectClients()
  303.     { SafeDelete(colp); }
  304.     void SetCurrent(Class *cp)
  305.     { current= cp; }
  306.     void Member(char *, int, int, int, Class *cl, bool, bool)
  307.     { if (clp == cl) colp->Add(current); }
  308.     Collection *GetCollection()
  309.     { return colp; }
  310. };
  311.  
  312. void PeClassTreeView::ShowAllClients(PeClassItem *ci)
  313. {
  314.     Class *cp;
  315.     PeCollectClients clm(ci->GetClass());
  316.     Iter next(gClassManager->Iterator());
  317.     while (cp= (Class*)next()) {
  318.     clm.SetCurrent(cp);
  319.     cp->EnumerateMyMembers(&clm);
  320.     }
  321.     Collection *colItems= new OrdCollection;
  322.     Iter next2(clm.GetCollection());
  323.     while (cp= (Class *)next2()) 
  324.     colItems->Add(FindClassItem(cp));
  325.     AddReference (new PeClassReference(ci, colItems, ePatBlack));        
  326. }
  327.  
  328. PeClassItem *PeClassTreeView::FindClassItem(Class *cp)
  329. {
  330.     PeClassItem dummy(0,cp);
  331.     return (PeClassItem*)classes->Find(&dummy);
  332. }
  333.  
  334. TreeNode *PeClassTreeView::FindTreeNode(VObject *vop)
  335. {
  336.     return (TreeNode*)vop->FindNextHandlerOfClass(Meta(TreeNode));
  337. }
  338.  
  339. //---- NameTreeNodeSelector -------------------------------------------------------------
  340.  
  341. PeNameTreeNodeSelector::PeNameTreeNodeSelector(TreeNode *tn, int cl)
  342. {
  343.     item= tn;
  344.     lastinside= FALSE;
  345.     clicks= cl;
  346.     fp= gFixedFont->WithFace(eFaceBold);
  347.     VObject *vop= tn->At(0)->FindItem(cIdClassItem);
  348.     if (vop && vop->IsKindOf(PeClassItem)) 
  349.     name= ((PeClassItem*)vop)->ClassName();
  350.     p= vop->ContentRect().NE();
  351. }
  352.  
  353. void PeNameTreeNodeSelector::TrackFeedback(Point, Point, bool)
  354. {
  355.     if (item && (lastinside != inside)) {
  356.     GrShowString(fp, ePatXor, p, (byte*) name);
  357.     item->At(0)->Outline(0);
  358.     lastinside= inside;
  359.     }
  360. }
  361.  
  362. Command *PeNameTreeNodeSelector::TrackMouse(TrackPhase atp, Point, Point, Point np)
  363. {
  364.     VObject *image= item->At(0);
  365.     inside= image->ContainsPoint(np);
  366.     if (atp == eTrackRelease) {
  367.     if (item && lastinside) {
  368.         GrShowString(fp, ePatXor, p, (byte*) name);
  369.         image->Outline(0);
  370.         item->GetTreeView()->SetSelection(image);
  371.         return item->GetTreeView()->NodeSelected(item->At(0), clicks);
  372.     }                
  373.     }
  374.     return this; 
  375. }
  376.  
  377. //---- PeClassReference --------------------------------------------------------------------------
  378.  
  379. PeClassReference::PeClassReference(PeClassItem *c, Collection *refs, GrPattern p, int w)
  380. {
  381.     cl= c;
  382.     nodes= refs;
  383.     width= w;
  384.     pat= p;
  385. }
  386.  
  387. PeClassReference::~PeClassReference()
  388. {
  389.     SafeDelete(nodes);
  390. }
  391.  
  392. bool PeClassReference::Includes(PeClassItem *ci)
  393. {
  394.     return nodes->ContainsPtr(ci) || (ci == cl);
  395. }
  396.  
  397. void PeClassReference::Draw(Rectangle)
  398. {
  399.     PeClassItem *clp;
  400.     Iter next(nodes);
  401.  
  402.     if (!cl->IsOpen())
  403.     return;
  404.     GrSetPenNormal();
  405.     GrStrokeRect(cl->contentRect.Expand(1)); 
  406.     while (clp= (PeClassItem*)next()) {
  407.     if (clp->IsOpen()) {
  408.         GrSetPenNormal();
  409.         GrStrokeRect(clp->ContentRect().Expand(1));
  410.         DrawConnection(cl, clp);
  411.     }
  412.     }
  413. }
  414.  
  415. void PeClassReference::DrawConnection(PeClassItem *from, PeClassItem *to)
  416. {
  417.     GrMoveto(from->contentRect.Center());
  418.     GrSetPenSize(1);
  419.     SetWidthAndPattern(from, to);
  420.     
  421.     if (from == to) 
  422.     CircularReference(from);
  423.     else {
  424.     GrMoveto(from->contentRect.Center());
  425.     GrLineto(to->contentRect.Center());
  426.     }
  427. }
  428.  
  429. static RGBColor *c2;
  430.  
  431. void PeClassReference::SetWidthAndPattern(PeClassItem*, PeClassItem*)
  432. {
  433.     if (c2 == 0)
  434.     c2= new_RGBColor(0, 256, 0);
  435.     GrSetPenSize(width);
  436.     GrSetPenInk(c2);
  437. }
  438.  
  439. void PeClassReference::CircularReference(PeClassItem *ci)
  440. {
  441.     int d= ci->ContentRect().Height();
  442.     Rectangle rr(ci->ContentRect().NE()-Point(d/2), Point(d)); 
  443.     GrStrokeOval(rr);
  444. }
  445.  
  446. Rectangle PeClassReference::BBox()
  447. {
  448.     Rectangle r;
  449.     VObject *clp;
  450.     Iter next(nodes);
  451.   
  452.     r= cl->ContentRect().Expand(20);
  453.     while ((clp= (VObject *)next())) 
  454.     r.Merge(clp->ContentRect().Expand(4));
  455.     return r;
  456. }
  457.  
  458. //---- PeMemberReference ---------------------------------------------------------
  459.  
  460. PeMemberReference::PeMemberReference(PeClassItem *cl, Collection *n) : 
  461.                                PeClassReference(cl, n)
  462. {
  463. }
  464.  
  465. void PeMemberReference::SetWidthAndPattern(PeClassItem*, PeClassItem*)
  466. {
  467.     if (c1 == 0)
  468.     c1= new RGBColor(256, 0, 0);
  469.     GrSetPenInk(c1);
  470. }
  471.  
  472. //---- PeHierarchyBrowser --------------------------------------------------------
  473.  
  474. NewMetaImpl(PeHierarchyBrowser,EtPeTool, (TP(ct)));
  475.  
  476. PeHierarchyBrowser *PeHierarchyBrowser::hierBrowser;
  477.  
  478. PeHierarchyBrowser::PeHierarchyBrowser(Manager *m, Class *root)
  479.                         : EtPeTool(m, "Class Hierarchy")
  480. {
  481.     ct= new PeClassTreeView(this, root);
  482. }
  483.  
  484. VObject *PeHierarchyBrowser::DoMakeContent()
  485. {
  486.     hierZoomer= new Zoomer(ct);
  487.     hierZoomer->SetBgInk(gInkNone);
  488.     SetFirstHandler(ct);
  489.     return new VExpander(gPoint5,
  490.     hierZoomer,
  491.     0
  492.     );
  493. }
  494.  
  495. Point PeHierarchyBrowser::GetInitialWindowSize()
  496. {
  497.     return Point(600,600);
  498. }
  499.  
  500. PeHierarchyBrowser::~PeHierarchyBrowser()
  501. {
  502.     SafeDelete(ct);
  503. }
  504.  
  505. MenuBar *PeHierarchyBrowser::DoMakeMenuBar()
  506. {
  507.     MenuBar *mb= EtPeTool::DoMakeMenuBar();
  508.     
  509.     Menu *m= Zoomer::MakeMenu(cVIEWMENU);
  510.     m->InsertItemsBefore(cZOOMOUT,
  511.             "Tree",                    cTREEVIEW,
  512.             "Outline",                 cOUTLINEVIEW,
  513.             "-",
  514.             "All Classes",             cALLCLASSES,
  515.             "Abstract Classes",        cONLYABSTRACT,
  516.             "Application Classes",     cONLYAPPL,
  517.             "-",
  518.             0);                      
  519.     mb->AddMenu(m);
  520.  
  521.     m= new Menu("Classes");
  522.     m->AppendItems(
  523.             "Members",                  cMEMBERS,
  524.             "Clients",                  cCLIENTS,
  525.             "Show Source",              cSOURCE,
  526.             "-",
  527.             "Clear Lines",              cCLEARREFS,
  528.             "-",
  529.             "Collapse",                 cDOCOLLAPSE,
  530.             "Promote",                  cPROMOTE,
  531.             0);  
  532.     mb->AddMenu(m);
  533.                         
  534.     return mb;
  535. }
  536.  
  537. void PeHierarchyBrowser::DoSetupMenu(Menu *mp)
  538. {
  539.     EtPeTool::DoSetupMenu(mp);
  540.     Clipper *vf= hierZoomer->GetClipper();
  541.     if (vf->GetZoom() < 1024)
  542.     mp->EnableItem(cZOOMIN);
  543.     if (vf->GetZoom() > 0.01)
  544.     mp->EnableItem(cZOOMOUT);
  545.     
  546.     mp->EnableItems(cZOOMRESET, cTREEVIEW, cOUTLINEVIEW, 0);
  547.     mp->CheckItem(cOUTLINEVIEW, ct->GetLayout() == eTLIndented);
  548.     mp->CheckItem(cTREEVIEW, ct->GetLayout() == eTLLeftRight);
  549.     
  550.     mp->CheckItem(cALLCLASSES, ct->Shows() == ePeCTShowAll);
  551.     mp->CheckItem(cONLYABSTRACT, ct->Shows() == ePeCTShowAbstract);
  552.     mp->CheckItem(cONLYAPPL, ct->Shows() == ePeCTShowApp);
  553.     
  554.     mp->EnableItems(cMEMBERS, cCLIENTS, cSOURCE, cDOCOLLAPSE, cCLEARREFS,
  555.             cALLCLASSES, cONLYABSTRACT, cONLYAPPL, cPROMOTE, 0);
  556. }
  557.  
  558. Command *PeHierarchyBrowser::DoMenuCommand(int cmd)
  559. {
  560.     Clipper *vf= hierZoomer->GetClipper();
  561.     switch (cmd) {
  562.     case cZOOMOUT: 
  563.     vf->SetZoom(vf->GetZoom()/1.2);
  564.     break;
  565.     
  566.     case cZOOMIN:
  567.     vf->SetZoom(vf->GetZoom()*1.2);
  568.     break;
  569.     
  570.     case cZOOMRESET:
  571.     vf->SetZoom(1.0);
  572.     break;
  573.     
  574.     case cONLYABSTRACT:
  575.     ct->ShowOnlyAbstractClasses();
  576.     break;
  577.     
  578.     case cONLYAPPL:
  579.     ct->ShowOnlyApplicationClasses();
  580.     break;
  581.     
  582.     case cALLCLASSES:
  583.     ct->ShowAllClasses();
  584.     break; 
  585.     
  586.     case cCLEARREFS:
  587.     ct->RemoveAllReferences();
  588.     break;
  589.     
  590.     default:
  591.     return EtPeTool::DoMenuCommand(cmd);
  592.     }
  593.     return gNoChanges;
  594. }
  595.  
  596. void PeHierarchyBrowser::ShowClass(Class *cp)
  597. {
  598.     ct->ShowClass(cp);
  599. }
  600.   
  601. void PeHierarchyBrowser::Spawn(Manager *m, Class *root)
  602. {
  603.     PeHierarchyBrowser *hb= new PeHierarchyBrowser(m, root);
  604.     hb->SetOnDismiss(eMgrClose);
  605.     hb->Show();
  606. }
  607.  
  608. void PeHierarchyBrowser::ShowClass(Manager *m, Class *selection)
  609. {
  610.     if (hierBrowser == 0)
  611.     hierBrowser= new PeHierarchyBrowser(m, gClassManager->Find("Object"));
  612.     hierBrowser->Show();
  613.     hierBrowser->ShowClass(selection); 
  614. }
  615.  
  616.